Circular Implementation Details - Educational Content

The core logic for circular pointer updates in enQueue and deQueue operations.

Having established the distinct conditions for an empty and a full queue, we can now implement the core operations. Both enQueue and deQueue require a boundary check and then the circular update of their pointers.
The central component driving circularity and ensuring $O(1)$ performance is the modulo operator (%).
Key Operation: Pointer Increment & Wrap
$\text{pointer} = (\text{pointer} + 1) \ \% \ MAX\_SIZE$
enQueue (Insertion):
- Check: Verify the queue is not full.
- Update rear: Calculate the new rear index using the modulo operation. This handles wrapping (e.g., from index 4 to 0 when $MAX\_SIZE = 5$).
- Assign: Insert the new element at the new rear index.
deQueue (Removal):
- Check: Verify the queue is not empty.
- Retrieve: Get the element at the current front index.
- Update front: Calculate the new front index using the modulo operation.

The Modulo Operator

The modulo operator (%) is the cornerstone of the circular array implementation. It elegantly handles the "wrap-around" logic by finding the remainder of a division, ensuring that pointer indices always stay within the valid range of $0$ to $MAX\_SIZE - 1$.

Circular Queue Logic (Python)

1MAX_SIZE = 5 
2
3# Logic focusing on how rear is updated and data inserted
4def enqueue_logic(array, data, front, rear):
5    # 1. Check Full Condition (from previous slide)
6    if (rear + 1) % MAX_SIZE == front:
7        return array, front, rear, "Queue Full!"
8    
9    # 2. Update the rear pointer circularly
10    # Example: if rear was 4, (4 + 1) % 5 = 0
11    rear = (rear + 1) % MAX_SIZE
12    
13    # 3. Insert the data
14    array[rear] = data
15    
16    return array, front, rear, f"Enqueued '{data}'"
17
18# Setup for a wrap-around demonstration:
19# f=2, r=4. Array slots 2 & 3 are occupied. Slot 4 is reserved.
20array_wrap_setup = ['_', '_', 'C', 'D', '_']
21f_start, r_start = 2, 4
22
23array_new, f_new, r_new, status = enqueue_logic(array_wrap_setup, 'E', f_start, r_start)
24
25# -----------------------------------------------------------------
26
27# Logic focusing on how front is updated and data retrieved
28def dequeue_logic(array, front, rear):
29    # 1. Check Empty Condition
30    if front == rear:
31        return array, front, rear, "Queue Empty!"
32    
33    # 2. Retrieve data at current front
34    data = array[front]
35    
36    # 3. Update the front pointer circularly
37    front = (front + 1) % MAX_SIZE
38    
39    return array, front, rear, f"Dequeued '{data}'"
40
41# Dequeue from the new state (f=2, r=0)
42array_deq = array_new
43f_start_deq, r_start_deq = f_new, r_new 
44
45array_final, f_final, r_final, status_deq = dequeue_logic(array_deq, f_start_deq, r_start_deq)